// 首页逻辑
const app = getApp()
const RoomUtils = require('../../utils/roomUtils.js')

Page({
  data: {
    userInfo: null,
    userStats: {
      rank: 0,
      wins: 0,
      losses: 0,
      draws: 0,
      winRate: 0,
      totalScore: 0
    },
    rooms: [],
    loading: false,
    showInviteModal: false,
    createdRoom: null,
    qrCodeData: null,
    ads: [],
    pendingRoomCode: null,
    pagination: {
      currentPage: 1,
      pageSize: 10,
      totalCount: 0,
      totalPages: 0,
      hasNext: false,
      hasPrev: false
    }
  },

  onLoad(options) {
    // 处理继续游戏（从结算页面跳转过来）
    if (options && options.continue_game === '1') {
      const roomName = options.room_name ? decodeURIComponent(options.room_name) : ''
      console.log('继续游戏，房间名:', roomName)
      
      // 延迟一下，确保页面加载完成后再创建房间
      setTimeout(() => {
        if (roomName) {
          // 直接使用房间名创建新房间
          this.doCreateRoom(roomName)
        } else {
          // 如果没有房间名，弹出输入框
          this.showCreateRoomModal()
        }
      }, 500)
    }
    
    // 处理从二维码传入的参数
    if (options && options.from_user_id) {
      // 保存邀请者信息
      wx.setStorageSync('inviter_user_id', options.from_user_id)
      // 可以在这里显示一个提示，告知用户来自谁的邀请
      wx.showToast({
        title: '来自好友的邀请',
        icon: 'none',
        duration: 2000
      })
      // 可以选择自动刷新房间列表，或者稍后在onShow中处理
    }
    
    // 检查是否有待处理的房间代码（从闪屏页传来的）
    const pendingRoomCode = wx.getStorageSync('pending_room_code');
    if (pendingRoomCode) {
      console.log('发现待处理的房间代码:', pendingRoomCode);
      // 清除待处理标记
      wx.removeStorageSync('pending_room_code');
      // 保存房间代码以便后续处理
      this.setData({ pendingRoomCode });
    }
    
    this.checkLoginStatus()
    this.getRoomList()
    this.getAds()
    // getUserStats 会在 setUserInfo 中自动调用，但如果用户已经登录，这里也调用一次
    // 从全局数据获取用户信息（如果存在）
    const userInfo = getApp().globalData.userInfo || wx.getStorageSync('userInfo')
    if (userInfo && userInfo.id) {
      console.log('onLoad: 用户已登录，获取用户战绩')
      this.getUserStats()
    }
    this.updateTabbarStatus()
  },

  onShow() {
    console.log('首页onShow被调用')
    // 检查登录状态
    this.checkLoginStatus()
    
    // 如果用户已登录，刷新用户战绩（确保数据是最新的）
    const userInfo = this.data.userInfo || getApp().globalData.userInfo
    if (userInfo && userInfo.id) {
      console.log('用户已登录，刷新用户战绩')
      this.getUserStats()
    }
    
    // 检查用户是否在已结算的房间中，如果是则清除缓存
    this.checkAndClearSettledRoom()
    
    // 只在必要时刷新房间列表，避免频繁请求
    const lastRefreshTime = wx.getStorageSync('lastRoomListRefresh')
    const now = new Date().getTime()
    
    // 如果超过5分钟没有刷新，或者没有房间数据，才刷新
    if (!lastRefreshTime || (now - lastRefreshTime) > 300000 || !this.data.rooms || this.data.rooms.length === 0) {
      this.getRoomList()
      wx.setStorageSync('lastRoomListRefresh', now)
    }
    
    // 广告只在onLoad时加载一次，onShow不再重复加载
    // 避免广告闪烁和重复请求
    
    // 更新tabbar状态
    this.updateTabbarStatus()
    
    // 处理待加入的房间
    if (this.data.pendingRoomCode && this.data.userInfo) {
      this.handlePendingRoomJoin();
    }
  },

  // 分享给好友
  async onShareAppMessage() {
    const ShareUtil = require('../../utils/shareUtil')
    return await ShareUtil.generateShareAppMessageConfig('index', {
      rooms: this.data.rooms
    })
  },

  // 分享到朋友圈
  async onShareTimeline() {
    const ShareUtil = require('../../utils/shareUtil')
    return await ShareUtil.generateShareTimelineConfig('index', {
      rooms: this.data.rooms
    })
  },


  // 检查并清除已结算的房间缓存
  checkAndClearSettledRoom() {
    const RoomCache = require('../../utils/roomCache')
    const roomData = RoomCache.getRoomBasicInfo()
    
    if (!roomData || !roomData.id) {
      return // 没有房间数据，无需处理
    }
    
    // 检查房间是否已结算
    if (RoomUtils.isRoomSettled(roomData)) {
      console.log('检测到已结算的房间，清除缓存')
      RoomUtils.clearAllRoomCache()
      
      wx.showToast({
        title: '房间已结算，请创建新房间',
        icon: 'none',
        duration: 2000
      })
    }
  },

  // 处理待加入的房间
  handlePendingRoomJoin() {
    console.log('handlePendingRoomJoin 被调用', {
      pendingRoomCode: this.data.pendingRoomCode,
      userInfo: this.data.userInfo
    });
    
    if (!this.data.pendingRoomCode || !this.data.userInfo) {
      console.log('条件不满足，无法加入房间:', {
        pendingRoomCode: this.data.pendingRoomCode,
        userInfo: this.data.userInfo
      });
      return;
    }
    
    const roomCode = this.data.pendingRoomCode;
    console.log('尝试加入房间:', roomCode);
    
    wx.showLoading({ title: '正在加入房间...' });
    
    wx.request({
      url: `${getApp().globalData.baseUrl}/api/room/get-by-code`,
      method: 'GET',
      data: {
        room_code: roomCode
      },
      success: (res) => {
        if (res.data.success) {
          const room = res.data.data.room;
          
          // 尝试加入房间
          wx.request({
            url: `${getApp().globalData.baseUrl}/api/room/join`,
            method: 'POST',
            data: {
              room_code: roomCode,
              user_id: this.data.userInfo.id
            },
            success: (joinRes) => {
              if (joinRes.data.success) {
                // 保存房间信息到缓存
                const RoomCache = require('../../utils/roomCache');
                RoomCache.saveRoom(room, { isNewRoom: false });
                
                // 清除待处理标记
                this.setData({ pendingRoomCode: null });
                
                wx.showToast({
                  title: '成功加入房间',
                  icon: 'success'
                });
                
                // 跳转到房间页面，确保传递roomCode参数
                wx.navigateTo({
                  url: `/pages/room/room?roomCode=${roomCode}`
                });
              } else {
                wx.showToast({
                  title: joinRes.data.message || '加入房间失败',
                  icon: 'none'
                });
                // 清除待处理标记
                this.setData({ pendingRoomCode: null });
              }
            },
            fail: (err) => {
              console.error('加入房间失败:', err);
              wx.showToast({
                title: '网络错误，请重试',
                icon: 'none'
              });
              // 清除待处理标记
              this.setData({ pendingRoomCode: null });
            },
            complete: () => {
              wx.hideLoading();
            }
          });
        } else {
          wx.showToast({
            title: res.data.message || '房间不存在',
            icon: 'none'
          });
          // 清除待处理标记
          this.setData({ pendingRoomCode: null });
        }
      },
      fail: (err) => {
        console.error('获取房间信息失败:', err);
        wx.showToast({
          title: '网络错误，请重试',
          icon: 'none'
        });
        // 清除待处理标记
        this.setData({ pendingRoomCode: null });
      },
      complete: () => {
        wx.hideLoading();
      }
    });
  },
  
  // 检查登录状态
  checkLoginStatus() {
    const app = getApp()
    console.log('检查登录状态:', {
      isLoggedIn: app.globalData.isLoggedIn,
      userInfo: app.globalData.userInfo
    })
    
    if (app.globalData.isLoggedIn && app.globalData.userInfo) {
      console.log('用户已登录，更新页面数据')
      this.setUserInfo(app.globalData.userInfo)
      // 如果有待处理的房间，尝试加入
      if (this.data.pendingRoomCode) {
        this.handlePendingRoomJoin();
      }
      // 确保获取用户战绩（setUserInfo 中会调用，但这里也调用一次确保数据加载）
      this.getUserStats()
    } else {
      console.log('用户未登录，开始登录流程')
      this.login()
    }
  },

  // 设置用户信息，处理头像URL
  setUserInfo(user) {
    if (!user) {
      return
    }
    
    if (user.avatar && !user.avatar.startsWith('http')) {
      user.avatarUrl = getApp().globalData.baseUrl + user.avatar
    } else {
      user.avatarUrl = user?.avatar || ''
    }
    
    const hadUserInfo = !!this.data.userInfo
    this.setData({ userInfo: user })
    
    // 如果之前没有用户信息，现在有了，则获取用户战绩
    if (!hadUserInfo && user.id) {
      console.log('首次设置用户信息，获取用户战绩')
      this.getUserStats()
    }
  },


  // 点击头像设置昵称
  onAvatarTap() {
    if (!this.data.userInfo) {
      wx.showToast({
        title: '请先登录',
        icon: 'none'
      })
      return
    }

    wx.showModal({
      title: '设置昵称',
      content: '请输入新昵称',
      editable: true,
      placeholderText: this.data.userInfo.nickname,
      success: (res) => {
        if (res.confirm && res.content) {
          this.updateNickname(res.content)
        }
      }
    })
  },

  // 更新昵称
  updateNickname(nickname) {
    wx.showLoading({ title: '更新中...' })
    wx.request({
      url: `${getApp().globalData.baseUrl}/api/user/create-or-update`,
      method: 'POST',
      data: {
        wechat_openid: this.data.userInfo.wechat_openid,
        nickname: nickname,
        avatar: this.data.userInfo.avatar
      },
      success: (res) => {
        if (res.data.success) {
          const user = res.data.data.user
          this.setUserInfo(user)
          getApp().setLoginStatus(user)
          wx.showToast({
            title: '昵称更新成功',
            icon: 'success'
          })
        } else {
          wx.showToast({
            title: res.data.message || '更新失败',
            icon: 'none'
          })
        }
      },
      complete: () => {
        wx.hideLoading()
      }
    })
  },

  // 用户登录
  login() {
    // 检查是否已经授权过
    this.checkAuthStatus()
  },

  // 检查授权状态
  checkAuthStatus() {
    const app = getApp()
    console.log('检查登录状态:', {
      isLoggedIn: app.globalData.isLoggedIn,
      userInfo: app.globalData.userInfo
    })
    
    if (app.globalData.isLoggedIn && app.globalData.userInfo) {
      console.log('用户已登录，更新页面数据')
      this.setUserInfo(app.globalData.userInfo)
      // 如果有待处理的房间，尝试加入
      if (this.data.pendingRoomCode) {
        this.handlePendingRoomJoin();
      }
    } else {
      console.log('用户未登录，检查是否已在授权页面')
      // 检查当前页面栈，避免重复跳转
      const pages = getCurrentPages()
      const currentPage = pages[pages.length - 1]
      if (currentPage.route !== 'pages/auth/auth') {
        console.log('跳转到授权页面')
        this.navigateToAuth()
      } else {
        console.log('已在授权页面，无需重复跳转')
      }
    }
  },

  // 显示授权对话框
  showAuthDialog() {
    wx.showModal({
      title: '需要授权',
      content: '请授权获取您的微信昵称和头像，以便为您提供更好的服务',
      confirmText: '去授权',
      cancelText: '暂不授权',
      success: (res) => {
        console.log('用户选择:', res.confirm ? '授权' : '拒绝')
        if (res.confirm) {
          // 用户选择授权，使用wx.getUserProfile
          console.log('用户点击了去授权，开始调用wx.getUserProfile')
          this.requestUserAuth()
        } else {
          // 用户拒绝授权，提示需要授权才能使用
          wx.showToast({
            title: '需要授权才能使用完整功能',
            icon: 'none'
          })
        }
      }
    })
  },

  // 跳转到授权页面
  navigateToAuth() {
    wx.navigateTo({
      url: '/pages/auth/auth',
      success: () => {
        console.log('跳转到授权页面成功')
      },
      fail: (err) => {
        console.log('跳转失败:', err)
        // 如果跳转失败，尝试使用旧版API
        this.tryLegacyAuth()
      }
    })
  },

  // 获取用户信息授权
  requestUserAuth() {
    // 使用wx.getUserProfile获取用户信息（官方推荐）
    if (wx.getUserProfile) {
      console.log('使用wx.getUserProfile获取用户信息')
      wx.getUserProfile({
        desc: '用于完善用户资料',
        success: (userRes) => {
          console.log('微信API返回的用户信息:', userRes)
          // 检查是否获取到真实用户信息
          if (userRes.userInfo && userRes.userInfo.nickName && userRes.userInfo.nickName !== '微信用户') {
            // 授权成功，创建用户
            this.createUser(userRes.userInfo)
          } else {
            // 获取到的是默认信息，提示用户
            wx.showToast({
              title: '请确保已设置微信昵称和头像',
              icon: 'none',
              duration: 3000
            })
            // 重新请求授权
            setTimeout(() => {
              this.showAuthDialog()
            }, 2000)
          }
        },
        fail: (err) => {
          console.log('getUserProfile失败:', err)
          this.showAuthError()
        }
      })
    } else {
      // 如果不支持getUserProfile，提示用户升级微信版本
      console.log('当前微信版本不支持getUserProfile')
      wx.showModal({
        title: '版本过低',
        content: '请升级微信到最新版本以使用完整功能',
        showCancel: false,
        confirmText: '确定'
      })
    }
  },

  // 显示授权错误
  showAuthError() {
    wx.showModal({
      title: '授权失败',
      content: '无法获取用户信息，请检查微信版本或重新尝试',
      showCancel: false,
      confirmText: '确定'
    })
  },


  // 创建用户
  createUser(userInfo) {
    console.log('从微信获取的用户信息:', userInfo)
    wx.showLoading({ title: '登录中...' })
    
    // 先获取微信登录凭证
    wx.login({
      success: (loginRes) => {
        if (loginRes.code) {
          // 获取用户手机号（用于获取unionid）
          this.getUserPhoneNumber(loginRes.code, userInfo)
        } else {
          wx.hideLoading()
          wx.showToast({
            title: '获取登录凭证失败',
            icon: 'none'
          })
        }
      },
      fail: (err) => {
        wx.hideLoading()
        console.error('微信登录失败:', err)
        wx.showToast({
          title: '登录失败，请重试',
          icon: 'none'
        })
      }
    })
  },

  // 获取用户手机号（用于获取unionid）
  getUserPhoneNumber(code, userInfo) {
    // 先尝试获取用户手机号
    wx.getUserProfile({
      desc: '用于完善用户资料',
      success: (profileRes) => {
        console.log('用户授权信息:', profileRes)
        this.sendUserData(code, userInfo, profileRes.userInfo)
      },
      fail: (err) => {
        console.log('获取用户授权信息失败，使用基础信息:', err)
        // 如果获取失败，仍然发送基础信息
        this.sendUserData(code, userInfo, null)
      }
    })
  },

  // 发送用户数据到后端
  sendUserData(code, userInfo, profileInfo) {
    console.log('发送到后端的数据:', {
      wechat_openid: code,
      wechat_unionid: profileInfo?.unionId || '',
      nickname: userInfo.nickName,
      avatar: userInfo.avatarUrl
    })
    
    // 先上传头像到服务器
    this.uploadAvatarAndCreateUser(code, userInfo, profileInfo)
  },

  // 上传头像并创建用户
  uploadAvatarAndCreateUser(code, userInfo, profileInfo) {
    const avatarPath = userInfo.avatarUrl
    
    // 检查是否是微信临时头像URL
    if (avatarPath && (avatarPath.includes('wxfile://') || avatarPath.includes('http://tmp'))) {
      // 是临时文件，需要上传到服务器
      console.log('检测到临时头像，开始上传到服务器...')
      
      wx.uploadFile({
        url: `${getApp().globalData.baseUrl}/api/user/upload-avatar`,
        filePath: avatarPath,
        name: 'avatar',
        formData: {
          user_id: 0 // 临时用户ID，创建用户后会被更新
        },
        success: (uploadRes) => {
          try {
            const uploadData = JSON.parse(uploadRes.data)
            if (uploadData.success && uploadData.data && uploadData.data.avatar_url) {
              console.log('头像上传成功:', uploadData.data.avatar_url)
              // 使用服务器返回的头像URL创建用户
              this.createUserWithAvatar(code, userInfo, profileInfo, uploadData.data.avatar_url)
            } else {
              console.error('头像上传失败，使用默认头像')
              this.createUserWithAvatar(code, userInfo, profileInfo, null)
            }
          } catch (parseError) {
            console.error('解析头像上传响应失败:', parseError)
            this.createUserWithAvatar(code, userInfo, profileInfo, null)
          }
        },
        fail: (uploadErr) => {
          console.error('头像上传请求失败:', uploadErr)
          // 上传失败，使用默认头像创建用户
          this.createUserWithAvatar(code, userInfo, profileInfo, null)
        }
      })
    } else {
      // 不是临时文件，直接创建用户
      this.createUserWithAvatar(code, userInfo, profileInfo, avatarPath)
    }
  },

  // 使用头像URL创建用户
  createUserWithAvatar(code, userInfo, profileInfo, avatarUrl) {
    wx.request({
      url: `${getApp().globalData.baseUrl}/api/user/create-or-update`,
      method: 'POST',
      data: {
        wechat_openid: code,
        wechat_unionid: profileInfo?.unionId || '',
        nickname: userInfo.nickName,
        avatar: avatarUrl || '' // 使用服务器返回的头像URL或空字符串
      },
      success: (res) => {
        console.log('登录API响应:', res.data)
        if (res.data.success) {
          const user = res.data.data.user
          console.log('用户数据:', user)
          
          this.setUserInfo(user)
          getApp().setLoginStatus(user)
          wx.showToast({
            title: '登录成功',
            icon: 'success'
          })
        } else {
          wx.showToast({
            title: res.data.message || '登录失败',
            icon: 'none'
          })
        }
      },
      fail: (err) => {
        console.error('登录请求失败:', err)
        wx.showToast({
          title: '网络错误，请重试',
          icon: 'none'
        })
      },
      complete: () => {
        wx.hideLoading()
      }
    })
  },

  // 获取房间列表
  getRoomList(page = 1) {
    this.setData({ loading: true })
    
    // 检查是否有邀请者信息
    const inviterUserId = wx.getStorageSync('inviter_user_id')
    
    // 构建请求参数
    const params = {
      page: page,
      page_size: this.data.pagination.pageSize
    }
    
    // 如果有邀请者信息，添加到请求参数中
    if (inviterUserId) {
      params.from_user_id = inviterUserId
    }
    
    wx.request({
      url: `${getApp().globalData.baseUrl}/api/room/list`,
      method: 'GET',
      data: params,
      success: (res) => {
        if (res.data.success) {
          // 如果是通过邀请链接进入，显示邀请者的房间列表
          if (inviterUserId) {
            wx.showModal({
              title: '邀请信息',
              content: '这是邀请您的好友创建的房间，点击进入即可加入！',
              showCancel: false,
              confirmText: '我知道了'
            })
            // 获取后清除邀请者信息，避免一直显示
            // wx.removeStorageSync('inviter_user_id')
          }
          
          const data = res.data.data
          this.setData({
            rooms: data.rooms || [],
            pagination: data.pagination || this.data.pagination
          })
        } else {
          wx.showToast({
            title: res.data.message || '获取房间列表失败',
            icon: 'none'
          })
        }
      },
      fail: (err) => {
        console.error('获取房间列表失败:', err)
        wx.showToast({
          title: '网络错误，请重试',
          icon: 'none'
        })
      },
      complete: () => {
        this.setData({ loading: false })
      }
    })
  },

  // 创建房间
  createRoom() {
    if (!this.data.userInfo) {
      wx.showToast({
        title: '请先登录',
        icon: 'none'
      })
      return
    }

    // 直接创建房间，使用默认名称
    this.doCreateRoom('打牌记账房间')
  },

  // 执行创建房间
  doCreateRoom(roomName) {
    wx.showLoading({ title: '创建中...' })
    wx.request({
      url: `${getApp().globalData.baseUrl}/api/room/create`,
      method: 'POST',
      data: {
        name: roomName,
        max_players: 4,
        user_id: this.data.userInfo.id
      },
      success: (res) => {
        if (res.data.success) {
          const room = res.data.data.room
          const isExistingRoom = res.data.data.is_existing_room
          
          // 如果响应中包含了用户列表，保存到房间数据中（用于房间页面立即显示）
          if (res.data.data.users && Array.isArray(res.data.data.users)) {
            console.log('创建房间响应中包含用户列表，用户数量:', res.data.data.users.length)
            // 将用户列表添加到room对象中，房间页面会使用它
            room.users = res.data.data.users
          }
          
          if (isExistingRoom) {
            // 用户已有活跃房间，直接进入现有房间
            wx.showToast({
              title: '进入现有房间',
              icon: 'success'
            })
          } else {
            // 新创建的房间
            wx.showToast({
              title: '房间创建成功',
              icon: 'success'
            })
          }
          
          // 自动加入房间并跳转
          this.autoJoinRoom(room, isExistingRoom)
        } else {
          wx.showToast({
            title: res.data.message || '创建失败',
            icon: 'none'
          })
        }
      },
      complete: () => {
        wx.hideLoading()
      }
    })
  },

  // 自动加入房间
  autoJoinRoom(room, isExistingRoom = false) {
    // 检查房间是否已结算
    if (RoomUtils.isRoomSettled(room)) {
      console.log('房间已结算，清除缓存并跳转到首页')
      RoomUtils.navigateToHome('房间已结算', '请创建新房间')
      return
    }
    
    // 使用统一的缓存管理
    const RoomCache = require('../../utils/roomCache')
    RoomCache.saveRoom(room, { isNewRoom: !isExistingRoom })
    
    // 更新tabbar状态
    this.updateTabbarStatus()
    
    // 确保全局用户信息已设置（WebSocket 需要）
    if (this.data.userInfo) {
      const app = getApp()
      app.setLoginStatus(this.data.userInfo)
      
      // 保存当前房间到全局，用于 WebSocket 自动订阅（使用 RoomCache 保存的格式）
      const cachedRoom = RoomCache.getRoom()
      if (cachedRoom) {
        app.globalData.currentRoom = cachedRoom.roomInfo
      } else {
        app.globalData.currentRoom = room
      }
      
      // 确保 WebSocket 连接并订阅房间
      app.ensureWebSocketConnection().then(() => {
        console.log('创建房间后：WebSocket 连接已确保')
        
        // 重要：等待连接完全建立并确保已发送 connect 消息
        const manager = app.getWebSocketManager()
        const waitForConnect = () => {
          if (manager.isConnected() && manager.connectMessageSent) {
            console.log('✅ 连接已建立且 connect 消息已发送')
            // 连接建立后，主动触发刷新房间订阅（封装的可复用函数）
            // 解决时序问题：用户在连接建立后才创建房间的情况
            setTimeout(() => {
              app.refreshRoomSubscriptions()
            }, 300) // 延迟300ms，确保连接完全稳定
          } else if (manager.isConnected() && !manager.connectMessageSent) {
            // 连接已建立但未发送 connect 消息，立即发送
            console.log('连接已建立但未发送 connect 消息，立即发送...')
            const sent = manager.ensureConnectMessageSent()
            if (sent) {
              setTimeout(() => {
                app.refreshRoomSubscriptions()
              }, 300)
            } else {
              // 如果发送失败，1秒后重试
              setTimeout(waitForConnect, 1000)
            }
          } else {
            // 连接未建立，等待或重试
            console.log('连接尚未建立，等待...')
            setTimeout(waitForConnect, 500)
          }
        }
        
        // 开始等待连接
        waitForConnect()
        
        // 最多等待10秒
        setTimeout(() => {
          if (!manager.isConnected() || !manager.connectMessageSent) {
            console.warn('⚠️ 等待超时：连接未建立或 connect 消息未发送')
            // 最后一次尝试
            if (manager.isConnected()) {
              manager.ensureConnectMessageSent()
            }
          }
        }, 10000)
      }).catch(err => {
        console.error('创建房间后初始化 WebSocket 失败:', err)
        // 即使失败，也尝试发送 connect 消息（如果连接已建立）
        const manager = app.getWebSocketManager()
        if (manager.isConnected()) {
          console.log('虽然 ensureWebSocketConnection 失败，但连接已建立，尝试发送 connect 消息')
          manager.ensureConnectMessageSent()
        }
      })
    }
    
    // 直接跳转到房间页面（带房间代码参数）
    wx.navigateTo({
      url: `/pages/room/room?roomCode=${room.room_code}`,
      success: () => {
        // 跳转成功后更新tabbar状态
        setTimeout(() => {
          this.updateTabbarStatus()
        }, 200)
      }
    })
  },

  // 显示邀请界面
  showInviteDialog(room) {
    this.setData({
      showInviteModal: true,
      createdRoom: room
    })
    // 生成二维码
    this.generateQRCode(room.room_code)
  },

  // 隐藏邀请界面
  hideInviteModal() {
    this.setData({
      showInviteModal: false,
      createdRoom: null,
      qrCodeData: null
    })
  },

  // 生成二维码
  generateQRCode(roomCode) {
    wx.request({
      url: `${getApp().globalData.baseUrl}/api/room/qrcode`,
      method: 'GET',
      data: {
        room_code: roomCode
      },
      success: (res) => {
        if (res.data.success) {
          this.setData({
            qrCodeData: res.data.data
          })
        } else {
          wx.showToast({
            title: '生成二维码失败',
            icon: 'error'
          })
        }
      },
      fail: (err) => {
        console.error('生成二维码失败:', err)
        wx.showToast({
          title: '网络错误',
          icon: 'error'
        })
      }
    })
  },

  // 进入房间
  enterCreatedRoom() {
    if (this.data.createdRoom) {
      // 确保使用navigateTo而不是switchTab，因为room不是tabBar页面
      wx.navigateTo({
        url: `/pages/room/room?roomCode=${this.data.createdRoom.room_code}`
      })
      this.hideInviteModal()
    }
  },

  // 复制房间代码
  copyRoomCode() {
    if (this.data.createdRoom) {
      wx.setClipboardData({
        data: this.data.createdRoom.room_code,
        success: () => {
          wx.showToast({
            title: '房间代码已复制',
            icon: 'success'
          })
        }
      })
    }
  },

  // 分享房间
  shareRoom() {
    if (this.data.createdRoom) {
      return {
        title: `打牌记账房间 ${this.data.createdRoom.room_code}`,
        path: `/pages/splash/splash?roomCode=${this.data.createdRoom.room_code}`,
        imageUrl: '/images/share-room.jpg'
      }
    }
  },

  // 扫码加入房间
  scanQRCode() {
    if (!this.data.userInfo) {
      wx.showToast({
        title: '请先登录',
        icon: 'none'
      })
      return
    }

    wx.scanCode({
      success: (res) => {
        console.log('扫码结果:', res)
        // 解析二维码内容，提取房间代码
        const qrContent = res.result
        console.log('二维码内容:', qrContent)
        
        // 尝试从二维码内容中提取房间代码
        // 支持多种格式：房间:8x0001, 8x0001, 打牌记账房间8x0001等
        let roomCode = null
        
        // 匹配格式：房间:8x0001
        const roomMatch1 = qrContent.match(/房间:([8x]\d+)/i)
        if (roomMatch1) {
          roomCode = roomMatch1[1]
        }
        
        // 匹配格式：8x0001
        const roomMatch2 = qrContent.match(/([8x]\d+)/i)
        if (roomMatch2) {
          roomCode = roomMatch2[1]
        }
        
        // 匹配格式：打牌记账房间8x0001
        const roomMatch3 = qrContent.match(/打牌记账房间([8x]\d+)/i)
        if (roomMatch3) {
          roomCode = roomMatch3[1]
        }
        
        if (roomCode) {
          console.log('提取到房间代码:', roomCode)
          this.doJoinRoom(roomCode)
        } else {
          wx.showToast({
            title: '无效的二维码',
            icon: 'none'
          })
        }
      },
      fail: (err) => {
        console.error('扫码失败:', err)
        if (err.errMsg !== 'scanCode:fail cancel') {
          wx.showToast({
            title: '扫码失败',
            icon: 'none'
          })
        }
      }
    })
  },



  // 执行加入房间
  doJoinRoom(roomCode) {
    if (!this.data.userInfo) {
      wx.showToast({
        title: '请先登录',
        icon: 'none'
      })
      return
    }

    wx.showLoading({ title: '加入中...' })
    wx.request({
      url: `${getApp().globalData.baseUrl}/api/room/get-by-code`,
      method: 'GET',
      data: { room_code: roomCode },
      success: (res) => {
        if (res.data.success) {
          // 存储房间信息到本地缓存
          wx.setStorageSync('currentRoom', {
            roomCode: roomCode,
            roomInfo: res.data.data,
            joinTime: new Date().getTime()
          })
          
          // 直接跳转，不显示toast，确保传递roomCode参数
          wx.navigateTo({
            url: `/pages/room/room?roomCode=${roomCode}`
          })
        } else {
          wx.showToast({
            title: res.data.message || '房间不存在',
            icon: 'none'
          })
        }
      },
      complete: () => {
        wx.hideLoading()
      }
    })
  },

  // 进入房间
  enterRoom(e) {
    const roomCode = e.currentTarget.dataset.roomCode
    wx.navigateTo({
      url: `/pages/room/room?roomCode=${roomCode}`
    })
  },

  // 下拉刷新
  onPullDownRefresh() {
    this.getRoomList()
    setTimeout(() => {
      wx.stopPullDownRefresh()
    }, 1000)
  },

  // 跳转到个人中心
  goToProfile() {
    wx.navigateTo({
      url: '/pages/profile/profile'
    })
  },

  // 上一页
  prevPage() {
    if (this.data.pagination.hasPrev) {
      const prevPage = this.data.pagination.currentPage - 1
      this.getRoomList(prevPage)
    }
  },

  // 下一页
  nextPage() {
    if (this.data.pagination.hasNext) {
      const nextPage = this.data.pagination.currentPage + 1
      this.getRoomList(nextPage)
    }
  },

  // 跳转到指定页
  goToPage(e) {
    const page = parseInt(e.currentTarget.dataset.page)
    if (page >= 1 && page <= this.data.pagination.totalPages) {
      this.getRoomList(page)
    }
  },

  // 获取广告列表
  getAds() {
    // 先检查本地缓存
    const cachedAds = wx.getStorageSync('cachedAds')
    const cacheTime = wx.getStorageSync('adsCacheTime')
    const now = new Date().getTime()
    
    // 如果缓存存在且未过期（1小时），直接使用缓存
    if (cachedAds && cacheTime && (now - cacheTime) < 3600000) {
      this.setData({
        ads: cachedAds
      })
      return
    }
    
    // 如果已经有广告数据，不重复请求
    if (this.data.ads && this.data.ads.length > 0) {
      return
    }
    
    wx.request({
      url: `${getApp().globalData.baseUrl}/api/ad/list`,
      method: 'GET',
      data: {
        position: 'home',
        status: 'active'
      },
      success: (res) => {
        if (res.data.success && res.data.data.ads) {
          const ads = res.data.data.ads
          this.setData({
            ads: ads
          })
          // 缓存广告数据
          wx.setStorageSync('cachedAds', ads)
          wx.setStorageSync('adsCacheTime', now)
        } else {
          // 如果接口失败，使用默认广告
          this.setDefaultAds()
        }
      },
      fail: (err) => {
        console.error('获取广告失败:', err)
        // 使用默认广告
        this.setDefaultAds()
      }
    })
  },

  // 设置默认广告
  setDefaultAds() {
    this.setData({
      ads: [{
        id: 1,
        title: '无尽冬日',
        desc: '大哥,来一局?',
        image: '/images/ad1.jpg',
        url: 'https://example.com/game1'
      }]
    })
  },

  // 点击广告
  clickAd(e) {
    const ad = e.currentTarget.dataset.ad
    if (ad && ad.url) {
      // 记录广告点击
      this.recordAdClick(ad.id)
      
      // 跳转到广告链接
      wx.navigateTo({
        url: `/pages/webview/webview?url=${encodeURIComponent(ad.url)}&title=${encodeURIComponent(ad.title)}`
      })
    }
  },

  // 记录广告点击
  recordAdClick(adId) {
    wx.request({
      url: `${getApp().globalData.baseUrl}/api/ad/click`,
      method: 'POST',
      data: {
        ad_id: adId,
        user_id: this.data.userInfo?.id,
        position: 'home'
      },
      success: (res) => {
        console.log('广告点击记录成功')
      },
      fail: (err) => {
        console.error('记录广告点击失败:', err)
      }
    })
  },

  // 获取用户战绩
  getUserStats() {
    // 优先从 this.data.userInfo 获取，如果没有则从全局数据获取
    const userInfo = this.data.userInfo || getApp().globalData.userInfo
    
    if (!userInfo || !userInfo.id) {
      console.log('用户信息不存在，跳过获取战绩')
      return
    }

    console.log('获取用户战绩，用户ID:', userInfo.id)
    
    wx.request({
      url: `${getApp().globalData.baseUrl}/api/user/stats`,
      method: 'GET',
      data: {
        user_id: userInfo.id
      },
      success: (res) => {
        console.log('用户战绩响应:', res.data)
        if (res.data.success && res.data.data) {
          this.setData({
            userStats: res.data.data
          })
        } else {
          console.warn('获取用户战绩失败，响应数据:', res.data)
          // 设置默认值
          this.setData({
            userStats: {
              rank: 0,
              wins: 0,
              losses: 0,
              draws: 0,
              winRate: 0,
              totalScore: 0
            }
          })
        }
      },
      fail: (err) => {
        console.error('获取用户战绩失败:', err)
        // 设置默认值
        this.setData({
          userStats: {
            rank: 0,
            wins: 0,
            losses: 0,
            draws: 0,
            winRate: 0,
            totalScore: 0
          }
        })
      }
    })
  },

  // 跳转到用户战绩页面
  goToUserRecords() {
    if (!this.data.userInfo) {
      wx.showToast({
        title: '请先登录',
        icon: 'none'
      })
      return
    }

    wx.navigateTo({
      url: '/pages/user-records/user-records'
    })
  },

  // 更新tabbar状态
  updateTabbarStatus() {
    const tabbarComponent = this.selectComponent('#customTabbar')
    if (tabbarComponent && typeof tabbarComponent.setCurrentPage === 'function') {
      const RoomCache = require('../../utils/roomCache')
      const roomData = RoomCache.getRoomBasicInfo()
      tabbarComponent.updateTabbarStatus(!!roomData)
      // 设置当前页面为选中状态
      tabbarComponent.setCurrentPage()
    }
  },

})
